package com.intretech.umsin.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.intretech.umsin.common.entity.DictModel;
import com.intretech.umsin.system.converter.SysDictItemVoEntityConverter;
import com.intretech.umsin.system.entity.SysDictItemEntity;
import com.intretech.umsin.system.mapper.SysDictItemMapper;
import com.intretech.umsin.system.param.SysDictItemParam;
import com.intretech.umsin.system.service.SysDictItemService;
import com.intretech.umsin.system.vo.SysDictItemVo;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Optional;



/**
* @version V1.0
* 系统字典详情信息:sys_dict_item 对应商业服务实现.
* @ClassName: SysDictItemServiceImpl
* @Description: 系统字典详情信息:sys_dict_item 对应商业服务实现.
* @author: 李启联
* @date:   2022-8-6 14:37:22
* @Copyright: Copyright (c) 2022
*/
@Service
public class SysDictItemServiceImpl extends ServiceImpl<SysDictItemMapper, SysDictItemEntity> implements SysDictItemService {

    @Autowired
    private SysDictItemVoEntityConverter sysDictItemVoEntityConverter;


    /**
    * 根据ID查询单个系统字典详情信息对象
    * @param id 组键ID
    * @return 单个系统字典详情信息VO对象
    */
    public SysDictItemVo queryById(Serializable id){
        if (id == null) {return null;}
        return sysDictItemVoEntityConverter.reverseFromTarget(this.getById(id));
    }


    /**
    * 根据ID集合查询返回系统字典详情信息列表
    * @param idList 组键ID集合
    * @return 系统字典详情信息列表
    */
    public List<SysDictItemVo> queryByIds(Collection<? extends Serializable> idList){
        if(CollectionUtils.isEmpty(idList)){return null;}
        return sysDictItemVoEntityConverter.reverseFromTarget(this.listByIds(idList));
    }


    /**
    * 分页查询 系统字典详情信息 信息
    * @param page 分页对象
    * @param param 查询参数
    * @return IPage<SysDictItemVo> 分页对象
    */
    @Override
    public IPage<SysDictItemVo> queryForPage(IPage page,SysDictItemParam param){
      IPage<SysDictItemEntity> page0 = this.page(page,createQueryWrapper(param));
      IPage<SysDictItemVo> pageResult = page0.convert(e -> sysDictItemVoEntityConverter.reverseFromTarget(e));
      return pageResult;
    }


    /**
    * 根据条件查询返回 系统字典详情信息 对象列表
    * @param  param 查询参数
    * @return 系统字典详情信息 对象列表
    */
    @Override
    public List<SysDictItemVo> queryForList(SysDictItemParam param) {
        List<SysDictItemEntity> list = this.list(createQueryWrapper(param));
        return sysDictItemVoEntityConverter.reverseFromTarget(list);
    }

    /**
    * 构建查询条件
    * @param param 查询参数实体对象
    * @return 构建后的QueryWrapper查询条件
    */
    private QueryWrapper<SysDictItemEntity> createQueryWrapper(SysDictItemParam param){
        QueryWrapper<SysDictItemEntity> queryWrapper = new QueryWrapper<>();
        if(ObjectUtils.isEmpty(param)) { return queryWrapper; }
        Optional<SysDictItemParam> op = Optional.of(param);
        queryWrapper.lambda()
                .eq(op.map(SysDictItemParam::getId).isPresent(),SysDictItemEntity::getId,param.getId())
                .eq(op.map(SysDictItemParam::getDictId).isPresent(),SysDictItemEntity::getDictId,param.getDictId())
                .eq(op.map(SysDictItemParam::getItemValue).filter(StringUtils::isNotBlank).isPresent(),SysDictItemEntity::getItemValue,param.getItemValue())
                .eq(op.map(SysDictItemParam::getItemText).filter(StringUtils::isNotBlank).isPresent(),SysDictItemEntity::getItemText,param.getItemText())
                .eq(op.map(SysDictItemParam::getDescription).filter(StringUtils::isNotBlank).isPresent(),SysDictItemEntity::getDescription,param.getDescription())
                .eq(op.map(SysDictItemParam::getSortOrder).isPresent(),SysDictItemEntity::getSortOrder,param.getSortOrder())
                .eq(op.map(SysDictItemParam::getStatus).isPresent(),SysDictItemEntity::getStatus,param.getStatus())
        ;
        return queryWrapper;
    }

    /**
    * 添加系统字典详情信息到数据库
    * @param vo  系统字典详情信息 VO对象
    * @return 添加后的系统字典详情信息 VO对象
    */
    @Override
    public SysDictItemVo add(SysDictItemVo vo) {
        if (ObjectUtils.isEmpty(vo)) {return null;}
        SysDictItemEntity entity = sysDictItemVoEntityConverter.convertToTarget(vo);
        if(this.save(entity)){
            return sysDictItemVoEntityConverter.reverseFromTarget(this.getById(entity.getId()));
        }else {
            throw new RuntimeException("添加 系统字典详情信息 单个对象失败!");
            //return null;
        }
    }

    /**
    * 添加系统字典详情信息集合列表到数据库
    * @param vos  系统字典详情信息 VO对象列表
    * @return 添加后的系统字典详情信息 VO对象集合列表
    */
    @Override
    public List<SysDictItemVo> adds(List<SysDictItemVo> vos) {
        if (CollectionUtils.isEmpty(vos)) { return null; }
        List<SysDictItemEntity> entities = sysDictItemVoEntityConverter.convertToTarget(vos);
        if(this.saveBatch(entities)){
            List<Serializable> ids = new ArrayList<>();
            entities.forEach(e->{ids.add(e.getId());});
            return sysDictItemVoEntityConverter.reverseFromTarget(this.listByIds(ids));
        }else {
           throw new RuntimeException("添加 系统字典详情信息 集合列表失败!");
           //return null;
        }
    }

    /**
    * 更新系统字典详情信息到数据库
    * @param vo 要更新的系统字典详情信息 VO对象
    * @return 更新后的系统字典详情信息 VO对象
    */
    @Override
    public SysDictItemVo modify(SysDictItemVo vo) {
        if (ObjectUtils.isEmpty(vo)) {return null;}
        SysDictItemEntity entity = sysDictItemVoEntityConverter.convertToTarget(vo);
        if(this.updateById(entity)){
            return sysDictItemVoEntityConverter.reverseFromTarget(this.getById(entity.getId()));
        }else {
            throw new RuntimeException("更新系统字典详情信息单个对象失败!");
            //return null;
        }
    }

    /**
    * 更新系统字典详情信息集合列表到数据库
    * @param vos 要更新的系统字典详情信息 VO对象集合
    * @return 更新后的系统字典详情信息 VO对象集合
    */
    @Override
    public List<SysDictItemVo> modifys(List<SysDictItemVo> vos) {
        if (CollectionUtils.isEmpty(vos)) { return null; }
        List<SysDictItemEntity> entities = sysDictItemVoEntityConverter.convertToTarget(vos);
        if(this.updateBatchById(entities)){
            List<Serializable> ids = new ArrayList<>();
            entities.forEach(e->{ids.add(e.getId());});
            return sysDictItemVoEntityConverter.reverseFromTarget(this.listByIds(ids));
        }else {
            throw new RuntimeException("更新系统字典详情信息集合列表失败!");
            //return null;
        }
    }

    /**
     * 根据字典类型编码查出对应的所有字典条目的数据集合
     * @param codes
     * @return
     */
    @Override
    @Cacheable(key="#p0",unless="#result==null")
    //@CacheExpire(expire = 1L)
    public List<DictModel> queryManyDictByDictCodes(List<String> codes) {
        if(CollectionUtils.isEmpty(codes)){return null;}
        return this.getBaseMapper().queryManyDictByDictCodes(codes);
    }


    /**
     * 通过查询指定table的 text code key 获取字典值
     * 查询字典表的数据 支持设置过滤条件、设置存储值作为in查询条件
     *
     * @param table 表名称 （或表名称 + " where k = 'v'"）
     * @param text  名称字段
     * @param code  码字段
     * @param keys  码名映射中“码”的值集合 支持批量查询
     * @return
     */
    @Override
    @Cacheable(key="#p0+'_'+#p1+'_'+#p2+'_'+#p3",unless="#result==null")
    //@CacheExpire(expire = 1L)
    public List<DictModel> queryTableDictByKeys(String table, String text, String code, List<String> keys) {
        String filterSql = null;
        if(table.toLowerCase().indexOf("where")>0){
            String[] arr = table.split(" (?i)where ");
            table = arr[0];
            filterSql = arr[1];
        }
        return this.getBaseMapper().queryTableDictByKeysAndFilterSql(table, text, code, filterSql, keys);
    }

}

